Flask 自定义装饰器：为安全 Web 应用程序实施路由保护

            
def my_decorator(func):
 def wrapper():
 print("Before function call.")
 func()
 print("After function call.")
 return wrapper

@my_decorator
def say_hello():
 print("Hello!")

say_hello() # Output: Before function call. \n Hello! \n After function call.
            

              
                Copy
              
            
          

            
import functools
import jwt
from flask import request, jsonify, current_app


def token_required(f):
 @functools.wraps(f)
 def decorated(*args, **kwargs):
 token = None

 if 'Authorization' in request.headers:
 token = request.headers['Authorization'].split(' ')[1]  # Extract token after 'Bearer '

 if not token:
 return jsonify({"message": "Token is missing!"}), 401

 try:
 data = jwt.decode(token, current_app.config['SECRET_KEY'], algorithms=['HS256'])
 # You'll likely want to fetch user data here from a database, etc.
 # For example: user = User.query.filter_by(id=data['user_id']).first()
 # Then, you can pass the user object to your view function (see next example)
 except jwt.ExpiredSignatureError:
 return jsonify({"message": "Token has expired!"}), 401
 except jwt.InvalidTokenError:
 return jsonify({"message": "Token is invalid!"}), 401

 return f(*args, **kwargs)

 return decorated

            

              
                Copy
              
            
          

            
from flask import Flask, jsonify

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key'

@app.route('/protected')
@token_required
def protected_route():
 return jsonify({"message": "This is a protected route!"}), 200

            

              
                Copy
              
            
          

            
import functools
from flask import request, jsonify, current_app

def role_required(role):
 def decorator(f):
 @functools.wraps(f)
 def wrapper(*args, **kwargs):
 # Assuming you have a way to get the user object
 # For example, if you're using the token_required decorator
 # and passing the user object to the view function:
 try:
 user = request.user # Assume you've set the user object in a previous decorator
 except AttributeError:
 return jsonify({"message": "User not authenticated!"}), 401

 if not user or user.role != role:
 return jsonify({"message": "Insufficient permissions!"}), 403

 return f(*args, **kwargs)

 return wrapper
 return decorator

            

              
                Copy
              
            
          

            
from flask import Flask, jsonify

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key'

# Assume the token_required decorator sets request.user (as described above)
@app.route('/admin')
@token_required  # Apply authentication first
@role_required('admin') # Then, apply authorization
def admin_route():
 return jsonify({"message": "Welcome, admin!"}), 200

            

              
                Copy
              
            
          

            
import functools
from flask import request, jsonify, current_app
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

# Initialize Limiter (ensure this is done during app setup)
limiter = Limiter(
 app=current_app._get_current_object(),
 key_func=get_remote_address,
 default_limits=["200 per day", "50 per hour"]
)

def rate_limit(limit):
 def decorator(f):
 @functools.wraps(f)
 @limiter.limit(limit)
 def wrapper(*args, **kwargs):
 return f(*args, **kwargs)
 return wrapper
 return decorator

# Example usage
@app.route('/api/resource')
@rate_limit("10 per minute")
def api_resource():
 return jsonify({"message": "API resource"})

            

              
                Copy
              
            
          

            
from functools import wraps
from flask import request, jsonify
from marshmallow import Schema, fields, ValidationError

# Define a schema for input validation
class UserSchema(Schema):
 email = fields.Email(required=True)
 password = fields.Str(required=True, min_length=8)

def validate_input(schema):
 def decorator(f):
 @wraps(f)
 def wrapper(*args, **kwargs):
 try:
 data = schema.load(request.get_json())
 except ValidationError as err:
 return jsonify(err.messages), 400
 request.validated_data = data # Store validated data in the request object
 return f(*args, **kwargs)
 return wrapper
 return decorator

# Example Usage
@app.route('/register', methods=['POST'])
@validate_input(UserSchema())
def register_user():
 # Access validated data from the request
 email = request.validated_data['email']
 password = request.validated_data['password']
 # ... process registration ...
 return jsonify({"message": "User registered successfully"})

            

              
                Copy